// create-allocation.js
const api = require('../../utils/api.js')
const permissionUtils = require('../../utils/permissions.js')
const pagePermission = require('../../utils/pagepermission.js')

Page({
  data: {
    // 表单数据
    orderIndex: -1,
    modelIndex: -1,
    processIndex: -1, // 保留但不使用，因为工序已经包含在型号选择中
    userIndex: -1,
    quantity: '',
    workTypeIndex: 0,
    remark: '',
    
    // 选项数据
    orders: [],
    orderModels: [], // 订单型号和工序组合列表
    processes: [], // 保留但不使用
    users: [],
    workTypes: ['计件', '计时'],
    
    // 状态
    submitting: false,
    estimatedWage: 0,
    
    // 型号选择器相关
    showModelSelector: false,
    searchKeyword: '',
    filteredOrderModels: [],
    tempModelIndex: -1 // 临时选择的型号索引
  },

  onLoad() {

    if (!pagePermission.requirePagePermission('pages/create-allocation/create-allocation')) {
      return
    }

    
    this.loadData()
  },

  // 加载数据
  loadData() {
    this.loadOrders()
    this.loadProcesses()
    this.loadUsers()
  },

  // 加载订单列表
  loadOrders() {
    api.getOrders({ page: 1, limit: 100 }).then(res => {
      this.setData({
        orders: res.data.list
      })
    }).catch(err => {
      console.error('加载订单失败:', err)
      wx.showToast({
        title: '加载订单失败',
        icon: 'none'
      })
    })
  },

  // 加载工序列表
  loadProcesses() {
    api.getProcesses().then(res => {
      this.setData({
        processes: res.data
      })
    }).catch(err => {
      console.error('加载工序失败:', err)
    })
  },

  // 加载员工列表
  loadUsers() {
    api.getUsers().then(res => {
      this.setData({
        users: res.data
      })
    }).catch(err => {
      console.error('加载员工失败:', err)
    })
  },

  // 订单选择
  onOrderChange(e) {
    const index = e.detail.value
    this.setData({
      orderIndex: index,
      modelIndex: -1,
      orderModels: []
    })
    
    if (index >= 0) {
      const order = this.data.orders[index]
      this.loadOrderModels(order.id)
    }
  },

  // 根据订单加载型号
  loadOrderModels(orderId) {
    api.getOrderModels(orderId).then(res => {
      // 处理数据，使用后端返回的display_name字段，包含批次信息
      const orderModels = res.data.map(item => ({
        ...item,
        // 如果后端返回了display_name，直接使用；否则构建一个
        display_name: item.display_name || `${item.model.product.name} - ${item.model.name} (${item.process.name})`
      }))
      
      this.setData({
        orderModels: orderModels
      })
      
      // 初始化过滤后的型号列表
      this.updateFilteredModels()
    }).catch(err => {
      console.error('加载订单型号失败:', err)
      wx.showToast({
        title: '加载型号失败',
        icon: 'none'
      })
    })
  },

  // 型号选择（现在包含工序）
  onModelChange(e) {
    const index = e.detail.value
    this.setData({
      modelIndex: index,
      processIndex: -1 // 重置工序选择
    })
    
    if (index >= 0) {
      this.calculateWage()
    }
  },

  // 工序选择
  onProcessChange(e) {
    this.setData({
      processIndex: e.detail.value
    })
    this.calculateWage()
  },

  // 员工选择
  onUserChange(e) {
    this.setData({
      userIndex: e.detail.value
    })
  },

  // 数量输入
  onQuantityInput(e) {
    this.setData({
      quantity: e.detail.value
    })
    this.calculateWage()
  },

  // 工作类型选择
  onWorkTypeChange(e) {
    this.setData({
      workTypeIndex: e.detail.value
    })
    this.calculateWage()
  },

  // 备注输入
  onRemarkInput(e) {
    this.setData({
      remark: e.detail.value
    })
  },

  // 显示型号选择器
  showModelSelector() {
    if (this.data.orderIndex < 0) {
      wx.showToast({
        title: '请先选择订单',
        icon: 'none'
      })
      return
    }
    
    // 初始化过滤后的型号列表
    this.updateFilteredModels()
    
    this.setData({
      showModelSelector: true,
      tempModelIndex: this.data.modelIndex
    })
  },

  // 隐藏型号选择器
  hideModelSelector() {
    this.setData({
      showModelSelector: false,
      searchKeyword: '',
      tempModelIndex: -1
    })
  },

  // 搜索输入
  onSearchInput(e) {
    const keyword = e.detail.value
    this.setData({
      searchKeyword: keyword
    })
    this.updateFilteredModels()
  },

  // 更新过滤后的型号列表
  updateFilteredModels() {
    const { orderModels, searchKeyword } = this.data
    let filtered = orderModels
    
    if (searchKeyword.trim()) {
      const keyword = searchKeyword.toLowerCase()
      filtered = orderModels.filter(item => {
        const productName = item.model?.product?.name?.toLowerCase() || ''
        const modelName = item.model?.name?.toLowerCase() || ''
        const processName = item.process?.name?.toLowerCase() || ''
        const displayName = item.display_name?.toLowerCase() || ''
        
        return productName.includes(keyword) || 
               modelName.includes(keyword) || 
               processName.includes(keyword) || 
               displayName.includes(keyword)
      })
    }
    
    // 为每个过滤后的项目添加原始索引
    const filteredWithIndex = filtered.map((item, index) => {
      const originalIndex = orderModels.findIndex(original => 
        original.model_id === item.model_id && 
        original.process_id === item.process_id &&
        original.order_model_id === item.order_model_id
      )
      console.log('过滤项目索引映射:', {
        item: item.display_name,
        originalIndex: originalIndex,
        model_id: item.model_id,
        process_id: item.process_id
      })
      return {
        ...item,
        originalIndex
      }
    })
    
    this.setData({
      filteredOrderModels: filteredWithIndex
    })
  },

  // 选择型号
  selectModel(e) {
    const index = e.currentTarget.dataset.index
    console.log('选择型号，索引:', index)
    this.setData({
      tempModelIndex: index
    })
  },

  // 确认型号选择
  confirmModelSelection() {
    const { tempModelIndex, orderModels } = this.data
    console.log('确认型号选择，tempModelIndex:', tempModelIndex)
    
    if (tempModelIndex >= 0) {
      this.setData({
        modelIndex: tempModelIndex,
        showModelSelector: false,
        searchKeyword: '',
        tempModelIndex: -1
      })
      
      // 计算工资
      this.calculateWage()
    } else {
      wx.showToast({
        title: '请先选择型号',
        icon: 'none'
      })
    }
  },

  // 阻止事件冒泡
  stopPropagation() {
    // 空函数，用于阻止事件冒泡
  },

  // 计算工资
  calculateWage() {
    const { modelIndex, processIndex, quantity, workTypeIndex } = this.data
    
    if (modelIndex >= 0 && quantity > 0) {
      const orderModel = this.data.orderModels[modelIndex]
      const workType = this.data.workTypes[workTypeIndex]
      
      // 这里可以根据工序工价计算，暂时使用固定价格
      let estimatedWage = 0
      if (workType == '计件') {
        estimatedWage = quantity * 10 // 假设每件10元
      } else {
        estimatedWage = quantity * 20 // 假设每小时20元
      }
      
      this.setData({
        estimatedWage: estimatedWage
      })
    } else {
      this.setData({
        estimatedWage: 0
      })
    }
  },

  // 提交创建分工
  submitAllocation() {
    const { orderIndex, modelIndex, userIndex, quantity, workTypeIndex, remark } = this.data
    
    // 验证表单
    if (orderIndex < 0) {
      wx.showToast({
        title: '请选择订单',
        icon: 'none'
      })
      return
    }
    
    if (modelIndex < 0) {
      wx.showToast({
        title: '请选择型号和工序',
        icon: 'none'
      })
      return
    }
    
    if (userIndex < 0) {
      wx.showToast({
        title: '请选择员工',
        icon: 'none'
      })
      return
    }
    
    if (!quantity || quantity <= 0) {
      wx.showToast({
        title: '请输入数量',
        icon: 'none'
      })
      return
    }
    
    // 验证数量不超过剩余可分配数量
    const orderModel = this.data.orderModels[modelIndex]
    if (parseInt(quantity) > orderModel.remaining_quantity) {
      wx.showToast({
        title: `数量不能超过剩余可分配数量(${orderModel.remaining_quantity})`,
        icon: 'none'
      })
      return
    }
    
    this.setData({ submitting: true })
    
    const order = this.data.orders[orderIndex]
    const user = this.data.users[userIndex]
    const workType = this.data.workTypes[workTypeIndex]
    
    const data = {
      order_id: order.id,
      model_id: orderModel.order_model_id || orderModel.id, // 使用订单型号ID，如果有的话
      process_id: orderModel.process_id, // 使用orderModel中的process_id
      user_id: user.id,
      quantity: parseInt(quantity),
      work_type: workType == '计件' ? 'piece' : 'time',
      remark: remark
    }
    
    api.createAllocation(data).then(res => {
      this.setData({ submitting: false })
      
      wx.showToast({
        title: '创建成功',
        icon: 'success'
      })
      
      // 返回上一页
      setTimeout(() => {
        wx.navigateBack()
      }, 1500)
      
    }).catch(err => {
      this.setData({ submitting: false })
      console.error('创建分工失败:', err)
      wx.showToast({
        title: err.msg || '创建失败',
        icon: 'none'
      })
    })
  },

  // 权限检查方法
  hasPermission(module, action) {
    const app = getApp()
    const adminInfo = app.globalData.adminInfo
    if (!adminInfo) {
      return false
    }
    return permissionUtils.hasPermission(adminInfo.id, module, action);
  },

  // 显示权限拒绝提示
  showPermissionDenied(module, action) {
    wx.showToast({
      title: `您没有${module}模块的${action}权限`,
      icon: 'none'
    })
  }
}) 